# coding: utf-8
import uuid
from datetime import datetime
from app.models.conversations import SjmlConversations, SjmlRecords
from app.extensions import db

class ConversationsService:
    """会话管理服务类，负责处理会话相关的业务逻辑"""
    
    @classmethod
    def get_conversations(cls, page=1, per_page=10, filters=None):
        """
        获取会话列表，支持分页和过滤
        
        Args:
            page: 当前页码，默认为1
            per_page: 每页记录数，默认为10
            filters: 过滤条件，字典格式
        
        Returns:
            dict: 包含会话列表、总数、页码等信息的字典
        """
        try:
            # 调用model层的方法获取数据
            conversations, pagination = SjmlConversations.get_list(page=page, per_page=per_page, filters=filters)
            
            # 转换为字典格式
            data = [conversation.to_dict() for conversation in conversations]
            
            # 构造返回结果
            result = {
                'items': data,
                'total': pagination.total,
                'page': pagination.page,
                'per_page': pagination.per_page,
                'pages': pagination.pages
            }
            
            return result
        except Exception as e:
            # 记录异常日志，这里可以根据项目的日志配置进行调整
            print(f'【获取会话列表业务逻辑错误:】{str(e)}')
            raise e
    
    @classmethod
    def process_null_values(cls, data):
        """
        处理数据中的null值，确保API返回的数据中不包含None值
        
        Args:
            data: 需要处理的数据
        
        Returns:
            dict: 处理后的数据集
        """
        # 由于models层的to_dict方法已经处理了items中的None值，这里只需处理分页信息中的None值
        return {
            'items': data.get('items') if data.get('items') is not None else [],
            'total': data.get('total') if data.get('total') is not None else 0,
            'page': data.get('page') if data.get('page') is not None else 1,
            'per_page': data.get('per_page') if data.get('per_page') is not None else 10,
            'pages': data.get('pages') if data.get('pages') is not None else 0
        }
    
    @classmethod
    def get_conversation_records(cls, conversation_id: str, page=1, per_page=50):
        """
        获取指定会话ID的记录列表，支持分页
        
        Args:
            conversation_id: 会话ID
            page: 当前页码，默认为1
            per_page: 每页记录数，默认为50
        
        Returns:
            dict: 包含记录列表、总数、页码等信息的字典
        """
        try:
            # 调用model层的方法获取数据
            records, total, current_page, current_per_page = SjmlRecords.get_by_conversation_id(
                conversation_id, 
                page=page, 
                per_page=per_page
            )
            
            # 计算总页数
            pages = (total + current_per_page - 1) // current_per_page
            
            # 转换为字典格式
            data = [record.to_dict() for record in records]
            
            # 反转列表，让最新的在最后
            data.reverse()
            
            # 构造返回结果
            result = {
                'items': data,
                'total': total,
                'page': current_page,
                'per_page': current_per_page,
                'pages': pages
            }
            
            return result
        except Exception as e:
            # 记录异常日志
            print(f'【获取会话记录业务逻辑错误:】{str(e)}')
            raise e

    @classmethod
    def create_conversation(cls, data):
        """
        创建新的会话
        
        Args:
            data: 包含会话信息的字典
                - name: 会话名称
                - user_id: 用户ID
                - status: 状态，默认为10
                - start_at: 开始时间
                - is_delete: 是否删除，默认为0
        
        Returns:
            dict: 创建的会话信息
        """
        try:
            # 生成UUID作为ID
            conversation_id = str(uuid.uuid4())
            
            # 创建会话对象
            conversation = SjmlConversations(
                id=conversation_id,
                name=data.get('name', f'会话-{datetime.now().strftime("%Y%m%d%H%M%S")}'),
                status=data.get('status', 10),
                create_at=datetime.now(),
                update_at=datetime.now(),
                start_at=data.get('start_at', datetime.now()),
                user_id=data.get('user_id', ''),
                is_delete=data.get('is_delete', 0)
            )
            
            # 添加到数据库并提交
            db.session.add(conversation)
            db.session.commit()
            
            # 返回创建的会话信息
            return conversation.to_dict()
        except Exception as e:
            # 发生异常时回滚事务
            db.session.rollback()
            # 记录异常日志
            print(f'【创建会话业务逻辑错误:】{str(e)}')
            raise e

    @classmethod
    def create_record(cls, data):
        """
        创建新的记录
        
        Args:
            data: 包含记录信息的字典
                - conversation_id: 会话ID
                - user_id: 用户ID
                - data_conf_id: 数据配置ID
                - step_title: 步骤标题（如'Step 2'）
                - current_state: 控制台输出内容
                - status: 状态，默认为10
                - is_delete: 是否删除，默认为0
                - message_type: 消息类型，默认为'bot'
        
        Returns:
            dict: 创建的记录信息
        """
        try:
            # 生成UUID作为ID
            record_id = str(uuid.uuid4())
            message_id = str(uuid.uuid4())
            
            # 创建记录对象
            record = SjmlRecords(
                id=record_id,
                query=data.get('step_title', ''),  # 使用步骤标题作为查询内容
                execute_datas=data.get('current_state', ''),  # 使用控制台输出内容作为执行数据
                conversation_id=data.get('conversation_id', ''),
                create_at=datetime.now(),
                update_at=datetime.now(),
                status=data.get('status', 10),
                user_id=data.get('user_id', ''),
                data_conf_id=data.get('data_conf_id', ''),
                is_delete=data.get('is_delete', 0),
                message_id=message_id,
                message_type=data.get('message_type', 'bot')
            )
            
            # 添加到数据库并提交
            db.session.add(record)
            db.session.commit()
            
            # 返回创建的记录信息
            return record.to_dict()
        except Exception as e:
            # 发生异常时回滚事务
            db.session.rollback()
            # 记录异常日志
            print(f'【创建会话记录业务逻辑错误:】{str(e)}')
            raise e